

/**
 * 移动节点函数
 * @param {HTMLElement} parentEl - 父节点 DOM 对象
 * @param {Array<string>} idsToMove - 需要移动的节点 id 数组
 * @param {string} targetId - 目标节点 id
 * @param {string} position - 'before' 或 'after'
 */
export function moveNodes(parentEl, idsToMove, targetId, position) {
  console.log(idsToMove, 'idsToMoveidsToMoveidsToMoveidsToMove');

  if (!parentEl) return;

  // 获取目标元素，使用 CSS.escape 确保特殊字符正确处理
  const targetEl = parentEl.querySelector(`#${CSS.escape(targetId)}`);
  if (!targetEl) {
    console.error("目标节点不存在");
    return;
  }

  // 收集需要移动的节点
  const nodesToMove = [];
  idsToMove.forEach(id => {
    const node = parentEl.querySelector(`#${CSS.escape(id)}`);
    if (node) {
      nodesToMove.push(node);
    } else {
      console.warn(`节点 id ${id} 未找到`);
    }
  });

  // 从 DOM 中移除这些节点（暂存到数组中）
  nodesToMove.forEach(node => node.parentNode.removeChild(node));

  // 插入节点
  if (position === 'before') {
    // 正序插入，保持顺序
    nodesToMove.forEach(node => {
      parentEl.insertBefore(node, targetEl);
    });
  } else if (position === 'after') {
    // 逆序插入，确保最终顺序和原数组一致
    for (let i = nodesToMove.length - 1; i >= 0; i--) {
      parentEl.insertBefore(nodesToMove[i], targetEl.nextSibling);
    }
  } else {
    console.error("position 参数必须为 'before' 或 'after'");
  }
}

// 删除节点
export function removeNodes(parentEl, idsToRemove) {
  if (!parentEl) {
    console.error("父级 DOM 元素不存在");
    return;
  }

  idsToRemove.forEach(id => {
    const node = parentEl.querySelector(`#${CSS.escape(id)}`);
    if (node) {
      node.remove(); // 直接删除节点
      console.log(`节点 ${id} 已删除`);
    } else {
      console.warn(`节点 id ${id} 未找到`);
    }
  });
}

// 添加节点
export function addNodeToTree(tree, id, data) {
  if (!Array.isArray(tree)) return;

  for (const node of tree) {
    if (node.id === id) {
      // 确保 children 存在
      if (!node.children) {
        node.children = [];
      }
      node.children.push(data);
      return true; // 添加成功，终止递归
    }

    // 递归查找子节点
    if (node.children && node.children.length) {
      const added = addNodeToTree(node.children, id, data);
      if (added) return true; // 找到目标节点后停止递归
    }
  }

  return false; // 未找到 id 对应的节点
}

//  查找节点
export const findNodeById = (tree, id) => {

  for (let i = 0; i < tree.length; i++) {
    if (tree[i].id === id) {
      return tree[i];
    }
    const result = findNodeById(tree[i].children, id);
    if (result) {
      return result;
    }
  }
  return null;
}


export function collectIds(node, result = []) {
  // 基准条件：检查当前节点是否符合条件（有子级且level≤3）
  if (node.level <= 3) {
    result.push(node.id);
  }
  // 递归处理子节点
  node.children.forEach(child => collectIds(child, result));
  return result;
}


/**
* 判断光标是否在指定元素（.child）内的开头
* @returns {boolean} - 是否光标在 .child 内的最前面  true禁用退格  false不处理
*/
export const isCaretAtStartFun = () => {
  const selection = window.getSelection();
  if (!selection.rangeCount) return false;
  const range = selection.getRangeAt(0);
  let currentNode = range.startContainer; // 当前光标所在的节点
  // 如果当前节点是文本节点，获取其父级
  if (currentNode.nodeType === Node.TEXT_NODE) {
    currentNode = currentNode.parentNode;
  }
  // 获取最近的 `.child` 父级
  const childParent = currentNode.closest('.child');
  if (!childParent) return false; // 不是 .child 内部，不处理
  // 检查是否光标位于 .child 内部的最前面
  const isAtStart = isCaretAtStart(range, childParent);
  console.log(1, isAtStart, childParent);

  if (isAtStart) {
    // 选中的内容为图片也会触发该事件，所以需要判断选中的内容是否为图片
    const selectedContent = range.cloneContents();
    const images = selectedContent.querySelectorAll('img');
    console.log(images, 'fowahfoafimages');
    if (images.length > 0) {
      return false;
    }else{
      console.warn('禁止删除：光标已在 .child 开头');
      return true
    }
    
  } else {
    return false;
  }
}
/**
* 判断光标是否在指定元素（.child）内的开头
* @param {Range} range - 选区范围对象
* @param {HTMLElement} parentElement - 目标父级（.child）
* @returns {boolean} - 是否光标在 .child 内的最前面
*/
function isCaretAtStart(range, parentElement) {
  let startContainer = range.startContainer;
  let offset = range.startOffset;

  // 处理空白文本（如果当前节点是全是空格的文本节点）
  while (startContainer.nodeType === Node.TEXT_NODE && startContainer.textContent.trim() === '') {
    startContainer = startContainer.previousSibling || startContainer.parentNode;
    if (!startContainer || startContainer === parentElement) return true; // 没有找到可见文本
  }
  // 如果当前是文本节点，检查光标左侧是否有内容（排除纯空格）
  if (startContainer.nodeType === Node.TEXT_NODE) {
    const leftText = startContainer.textContent.slice(0, offset);
    if (leftText.trim().length > 0) {
      return false; // 前面有内容，允许删除
    }
  }
  // 遍历前面的兄弟节点，看看是否有可见文本
  let node = startContainer;
  while (node && node !== parentElement) {
    if (node.previousSibling) {
      node = node.previousSibling;
      // 如果前面有非空的文本或可见元素，允许删除
      if (node.nodeType === Node.TEXT_NODE && node.textContent.trim() !== '') {
        return false;
      }
      if (node.nodeType === Node.ELEMENT_NODE && node.innerText.trim() !== '') {
        return false;
      }
    } else {
      node = node.parentNode;
    }
  }
  return true; // 说明前面没有任何内容，禁止删除
}